package com.example.hctorisrael.deadolympics;

   import android.content.res.AssetManager;
import android.util.Log;

import org.andengine.engine.Engine;
import org.andengine.engine.camera.Camera;
import org.andengine.opengl.texture.ITexture;
import org.andengine.opengl.texture.TextureManager;
import org.andengine.opengl.texture.TextureOptions;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlasTextureRegionFactory;
import org.andengine.opengl.texture.atlas.bitmap.BuildableBitmapTextureAtlas;
import org.andengine.opengl.texture.atlas.bitmap.source.IBitmapTextureAtlasSource;
import org.andengine.opengl.texture.atlas.buildable.builder.BlackPawnTextureAtlasBuilder;
import org.andengine.opengl.texture.atlas.buildable.builder.ITextureAtlasBuilder;
import org.andengine.opengl.texture.bitmap.AssetBitmapTexture;
import org.andengine.opengl.texture.region.ITextureRegion;
import org.andengine.opengl.texture.region.TextureRegionFactory;
import org.andengine.opengl.texture.region.TiledTextureRegion;
import org.andengine.opengl.vbo.VertexBufferObjectManager;

import java.io.IOException;

/**
 * Carga/Descarga los recurso del juego. Imágenes, Audios
 */
public class AdministradorRecursos
{
    // Instancia única de la clase
    private static final AdministradorRecursos INSTANCE =
            new AdministradorRecursos();

    public Engine engine;
    public ControlJuego actividadJuego;
    public Camera camara;
    public VertexBufferObjectManager vbom;

    // ** TEXTURAS **
    //***Escena Splash (imagen estática)
    private ITexture texturaSplash;
    public ITextureRegion regionSplash;

    //ESCENA ESTADO DEL JUEGO****
    //***Escena Estado Juego
    private ITexture texturaEstadoJuego;
    public ITextureRegion regionEstadoJuego;
    //Boton siguiente
    private ITexture texturaBotonSiguiente;
    public ITextureRegion regionBotonSiguiente;

    //**ESCENA PERDISTE
    private ITexture texturaGameOver;
    public ITextureRegion regionGameOver;
    //Boton siguiente
    private ITexture texturaBotonSiguienteGameOver;
    public ITextureRegion regionBotonSiguienteGameOver;

    //***Escena Menú
    private ITexture texturaFondoMenu;
    public ITextureRegion regionFondoMenu;
    // Botón jugar del menú
    private ITexture texturaBotonAcercaDe;
    public ITextureRegion regionBotonAcercaDe;
    private ITexture texturaBotonStart;
    public ITextureRegion regionBotonStart;
    private ITexture texturaBotonScores;
    public ITextureRegion regionBotonScores;
    private ITexture texturaBotonAyuda;
    public ITextureRegion regionBotonAyuda;

    //****Escena Acerca de
    private ITexture texturaFondoAcercaDe;
    public ITextureRegion regionFondoAcercaDe;

    //****Escena Scores
    private ITexture texturaFondoScores;
    public ITextureRegion regionFondoScores;

    //****Escena Scores
    private ITexture texturaFondoAyuda;
    public ITextureRegion regionFondoAyuda;

    //****ESCENA JUEGO
    private ITexture texturaFondoJuego;
    public ITextureRegion regionFondoJuego;
    //Botones y fondos PAUSA
    private ITexture texturaFondoPausa;
    public ITextureRegion regionFondoPausa;
    private BitmapTextureAtlas texturaBtnPausa;
    public ITextureRegion regionBtnPausa;
    private ITexture texturaBotonContinuar;
    public ITextureRegion regionBotonContinuar;
    private ITexture texturaBotonMenu;
    public ITextureRegion regionBotonMenu;
    //Muñeco Ganaste
    private BuildableBitmapTextureAtlas texturaMunecoGanador;
    public TiledTextureRegion regionMunecoGanador;
    //Muñeco Corriendo
    private BuildableBitmapTextureAtlas texturaMunecoCorriendo;
    public TiledTextureRegion regionMunecoCorriendo;
    //Muñeco quemandose
    private BuildableBitmapTextureAtlas texturaMunecoQuemandose;
    public TiledTextureRegion regionMunecoQuemandose;
    //Flecha Volando
    private BuildableBitmapTextureAtlas texturaFlechaVolando;
    public TiledTextureRegion regionFlechaVolando;
    //Hombre Muriendo 1
    private BuildableBitmapTextureAtlas texturaHombreMuriendo1;
    public TiledTextureRegion regionHombreMuriendo1;
    //Escena Ganaste
    private ITexture texturaFondoGanaste;
    public ITextureRegion regionFondoGanaste;
    //Fondos
    private ITexture texturaFondoBack;
    public ITextureRegion regionFondoBack;
    private ITexture texturaFondoFront;
    public ITextureRegion regionFondoFront;
    //mensaje perdiste
    private ITexture texturaPerdiste;
    public ITextureRegion regionPerdiste;
    //Mensaje Ganaste
    private ITexture texturaGanaste;
    public ITextureRegion regionGanaste;
    //Timer
    private BuildableBitmapTextureAtlas texturaTimer;
    public TiledTextureRegion regionTimer;
    // Botón de regreso
    private BitmapTextureAtlas texturaBtnRegresar;
    public ITextureRegion regionBtnRegresar;

    //****ESCENA JUEGO 2
    //Fondo
    private ITexture texturaFondoJuegoDos;
    public ITextureRegion regionFondoJuegoDos;
    //Shooter
    private ITexture texturaShooter;
    public ITextureRegion regionShooter;
    //Shooter con disparo
    private ITexture texturaShooterDisparo;
    public ITextureRegion regionShooterDisparo;
    //Bala
    public ITexture texturaBala;
    public ITextureRegion regionBala;
    //Botones y fondos de Pausa
    private ITexture texturaFondoPausaDos;
    public ITextureRegion regionFondoPausaDos;
    private BitmapTextureAtlas texturaBtnPausaDos;
    public ITextureRegion regionBtnPausaDos;
    private ITexture texturaBotonContinuarDos;
    public ITextureRegion regionBotonContinuarDos;
    private ITexture texturaBotonMenuDos;
    public ITextureRegion regionBotonMenuDos;
    //Cabezas
    private ITexture texturaCabezaHombre;
    public ITextureRegion regionCabezaHombre;
    //Timer
    private BuildableBitmapTextureAtlas texturaTimerDos;
    public TiledTextureRegion regionTimerDos;
    //Shooter Muriendo
    private BuildableBitmapTextureAtlas texturaShooterMuriendo;
    public TiledTextureRegion regionShooterMuriendo;

    //***Escena Juego Tres
    //Fondo
    private ITexture texturaFondoJuegoTres;
    public ITextureRegion regionFondoJuegoTres;
    //Botones y fondos de Pausa
    private ITexture texturaFondoPausaTres;
    public ITextureRegion regionFondoPausaTres;
    private BitmapTextureAtlas texturaBtnPausaTres;
    public ITextureRegion regionBtnPausaTres;
    private ITexture texturaBotonContinuarTres;
    public ITextureRegion regionBotonContinuarTres;
    private ITexture texturaBotonMenuTres;
    public ITextureRegion regionBotonMenuTres;
    //Nave moviendose
    private BuildableBitmapTextureAtlas texturaNave;
    public TiledTextureRegion regionNave;
    //Nave chocando
    private BuildableBitmapTextureAtlas texturaNaveChocando;
    public TiledTextureRegion regionNaveChocando;
    // Asteroide Enemigo
    private ITexture texturaAsteroide;
    public ITextureRegion regionAsteroide;
    //Timer
    private BuildableBitmapTextureAtlas texturaTimerTres;
    public TiledTextureRegion regionTimerTres;

    // Método accesor de la instancia
    public static AdministradorRecursos getInstance() {
        return INSTANCE;
    }

    // Asigna valores iniciales del administrador
    public static void inicializarAdministrador(Engine engine,
                                                ControlJuego control, Camera camara, VertexBufferObjectManager vbom) {

        getInstance().engine = engine;
        getInstance().actividadJuego=control;
        getInstance().camara = camara;
        getInstance().vbom = vbom;
    }

    //*** Recursos de la pantalla de Splash
    public void cargarRecursosSplash() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaSplash = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "Tec.png");
            regionSplash = TextureRegionFactory.extractFromTexture(texturaSplash);
            texturaSplash.load();
        } catch (IOException e) {
            Log.d("cargarRecursosSplash","No se puede cargar el fondo");
        }
    }

    public void liberarRecursosSplash() {
        texturaSplash.unload();
        regionSplash = null;
    }

    //**Recursos de la pantalla de Estado del Juego
    public void cargarRecursosEstadoJuego(){

        try {
            // Carga la imagen de fondo de la pantalla Estado Juego
            texturaEstadoJuego = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "fondoEstado.png");
            regionEstadoJuego = TextureRegionFactory.extractFromTexture(texturaEstadoJuego);
            texturaEstadoJuego.load();

            //Boton para mandar a la siguiente escena
            texturaBotonSiguiente = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "mano.png");
            regionBotonSiguiente = TextureRegionFactory.extractFromTexture(texturaBotonSiguiente);
            texturaBotonSiguiente.load();
        } catch (IOException e) {
            Log.d("cargarRecursosSplash","No se puede cargar el fondo");
        }
    }

    public void liberarRecursosEstadoJuego() {
        texturaEstadoJuego.unload();
        regionEstadoJuego = null;

        texturaBotonSiguiente.unload();
        regionBotonSiguiente = null;
    }

    //**Recursos de la pantalla de Perdiste
    public void cargarRecursosPerdiste(){

        try {
            // Carga la imagen de fondo de la pantalla Estado Juego
            texturaGameOver = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "gameOver.png");
            regionGameOver = TextureRegionFactory.extractFromTexture(texturaGameOver);
            texturaGameOver.load();

            //Boton para mandar a la siguiente escena
            texturaBotonSiguienteGameOver = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "mano.png");
            regionBotonSiguienteGameOver = TextureRegionFactory.extractFromTexture(texturaBotonSiguienteGameOver);
            texturaBotonSiguienteGameOver.load();
        } catch (IOException e) {
            Log.d("cargarRecursosSplash","No se puede cargar el fondo");
        }
    }

    public void liberarRecursosPerdiste() {
        texturaGameOver.unload();
        regionGameOver = null;

        texturaBotonSiguienteGameOver.unload();
        regionBotonSiguienteGameOver = null;
    }

    //*** Recursos de la pantalla de Menú
    public void cargarRecursosMenu() {
        try {
            // Carga la imagen de fondo de la pantalla del Menú
            texturaFondoMenu = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "menuprincipal.png");
            regionFondoMenu = TextureRegionFactory.extractFromTexture(texturaFondoMenu);
            texturaFondoMenu.load();
        } catch (IOException e) {
            Log.d("cargarRecursosMenu","No se puede cargar el fondo");
        }
        cargarBotonesMenu();
    }

    // Carga las imágenes de los botones del menú principal
    private void cargarBotonesMenu() {
        try {
            // Carga la imagen del botón acercaDe
            texturaBotonAcercaDe = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnAbout.png");
            regionBotonAcercaDe = TextureRegionFactory.extractFromTexture(texturaBotonAcercaDe);
            texturaBotonAcercaDe.load();

            // Carga la imagen para el botón start
            texturaBotonStart = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnStart.png");
            regionBotonStart = TextureRegionFactory.extractFromTexture(texturaBotonStart);
            texturaBotonStart.load();

            // Carga la imagen para el botón scores
            texturaBotonScores = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnScores.png");
            regionBotonScores = TextureRegionFactory.extractFromTexture(texturaBotonScores);
            texturaBotonScores.load();

            // Carga la imagen para el botón ayuda
            texturaBotonAyuda = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnAyuda.png");
            regionBotonAyuda = TextureRegionFactory.extractFromTexture(texturaBotonAyuda);
            texturaBotonAyuda.load();
        } catch (IOException e) {
            Log.d("cargarBotonesMenu", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosMenu() {
        // Fondo
        texturaFondoMenu.unload();
        regionFondoMenu = null;
        //Botones
        texturaBotonAcercaDe.unload();
        regionBotonAcercaDe = null;
        texturaBotonStart.unload();
        regionBotonStart = null;
        texturaBotonScores.unload();
        regionBotonScores = null;
        texturaBotonAyuda.unload();
        regionBotonAyuda = null;
    }

    //*** Recursos de la pantalla de Aerca De
    public void cargarRecursosAcercaDe() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoAcercaDe = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "Fondoabout.png");
            regionFondoAcercaDe = TextureRegionFactory.extractFromTexture(texturaFondoAcercaDe);
            texturaFondoAcercaDe.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128,128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego,"back.png",0,0);
            texturaBtnRegresar.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe","No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosAcercaDe() {
        // Fondo
        texturaFondoAcercaDe.unload();
        regionFondoAcercaDe = null;
        // Btn regresar
        texturaBtnRegresar.unload();
        regionBtnRegresar = null;
    }

    //*** Recursos de la pantalla de Ayuda
    public void cargarRecursosAyuda() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoAyuda = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "Instructions.png");
            regionFondoAyuda = TextureRegionFactory.extractFromTexture(texturaFondoAyuda);
            texturaFondoAyuda.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128,128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego,"back.png",0,0);
            texturaBtnRegresar.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe","No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosAyuda() {
        // Fondo
        texturaFondoAyuda.unload();
        regionFondoAyuda = null;
        // Btn regresar
        texturaBtnRegresar.unload();
        regionBtnRegresar = null;
    }

    public void cargarRecursosScores() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoScores = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "scores.jpg");
            regionFondoScores = TextureRegionFactory.extractFromTexture(texturaFondoScores);
            texturaFondoScores.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128,128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego,"back.png",0,0);
            texturaBtnRegresar.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe","No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosScores() {
        // Fondo
        texturaFondoScores.unload();
        regionFondoScores = null;
        // Btn regresar
        texturaBtnRegresar.unload();
        regionBtnRegresar = null;
    }

    public void cargarRecursosJuego() {
        try {
            //PARA NO LLAMAR AL METODO MUCHAS VECES
            TextureManager admTexturas = actividadJuego.getTextureManager();
            AssetManager assets = actividadJuego.getAssets();

            texturaFondoBack = new AssetBitmapTexture(actividadJuego.getTextureManager(), actividadJuego.getAssets(), "FondoLejos.jpg");
            regionFondoBack = TextureRegionFactory.extractFromTexture(texturaFondoBack);
            texturaFondoBack.load();
            texturaFondoFront = new AssetBitmapTexture(actividadJuego.getTextureManager(), actividadJuego.getAssets(), "FondoCerca.png");
            regionFondoFront = TextureRegionFactory.extractFromTexture(texturaFondoFront);
            texturaFondoFront.load();

            // Carga la imagen del botón pausa
            texturaBtnPausa = new BitmapTextureAtlas(actividadJuego.getTextureManager(), 128,128, TextureOptions.BILINEAR);
            regionBtnPausa = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnPausa, actividadJuego, "bPausa.png", 0, 0);
            texturaBtnPausa.load();

            //CARGAR MUÑECO GANADOR
            texturaMunecoGanador = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),1984,850);
            regionMunecoGanador = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaMunecoGanador, actividadJuego, "munecoGanaste.png", 7, 2);
            try {
                texturaMunecoGanador.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del munecoGanaste");
            }
            texturaMunecoGanador.load();

            //Fondo Pausa
            texturaFondoPausa = new AssetBitmapTexture(admTexturas,
                    assets, "fondoPausa.png");
            regionFondoPausa = TextureRegionFactory.extractFromTexture(texturaFondoPausa);
            texturaFondoPausa.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128,128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego,"back.png",0,0);
            texturaBtnRegresar.load();

            //CARGAR MUÑECO CORRIENDO
                    texturaMunecoCorriendo = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),1984,1279);
            regionMunecoCorriendo = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaMunecoCorriendo,actividadJuego, "munecoCorriendo.png",7,3);
            try {
                texturaMunecoCorriendo.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del munecoCorriendo");
            }
            texturaMunecoCorriendo.load();

            //CARGAR MUEÑECO QUEMANDOSE
            texturaMunecoQuemandose = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),2835,2835);
            regionMunecoQuemandose = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaMunecoQuemandose,actividadJuego, "explotando.png",2,4);
            try {
                texturaMunecoQuemandose.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del munecoQuemandose");
            }
            texturaMunecoQuemandose.load();

            //CARGAR FLECHA VOLANDO
            texturaFlechaVolando = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),1657,273);
            regionFlechaVolando = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaFlechaVolando,actividadJuego, "flechaVolando.png",6,1);
            try {
                texturaFlechaVolando.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del flechaCorriendo");
            }
            texturaFlechaVolando.load();
            //Cargar TIMER NIVEL 1
            texturaTimer = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),648,216);
            regionTimer = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaTimer,actividadJuego, "timer.png",6,2);
            try {
                texturaTimer.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
            }
            texturaTimer.load();
            //Cargar HOMBRE MURIENDO 1
            texturaHombreMuriendo1 = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),1800,2430);
            regionHombreMuriendo1 = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                    texturaHombreMuriendo1,actividadJuego, "hombreMuriendo1.png",4,9);
            try {
                texturaHombreMuriendo1.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
            } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
                Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
            }
            texturaHombreMuriendo1.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe","No se pueden cargar las imágenes");
        }
        cargarBotonesPausa();
    }

    private void cargarBotonesPausa() {
        try {
            // Carga la imagen del botón continuar
            texturaBotonContinuar = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnContinue.png");
            regionBotonContinuar = TextureRegionFactory.extractFromTexture(texturaBotonContinuar);
            texturaBotonContinuar.load();

            // Carga la imagen para el botón menu
            texturaBotonMenu = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnMenu.png");
            regionBotonMenu = TextureRegionFactory.extractFromTexture(texturaBotonMenu);
            texturaBotonMenu.load();

        } catch (IOException e) {
            Log.d("cargarBotonesMenu", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosJuego() {
        // Fondo
        texturaFondoBack.unload();
        regionFondoBack = null;
        texturaFondoFront.unload();
        regionFondoFront = null;
        //Timer
        texturaTimer.unload();
        regionTimer = null;
        //Sprites
        texturaHombreMuriendo1.unload();
        regionHombreMuriendo1 = null;
        texturaFlechaVolando.unload();
        regionFlechaVolando = null;
        //Pausa
        texturaBtnPausa.unload();
        regionBtnPausa = null;
        texturaFondoPausa.unload();
        regionFondoPausa=null;
        texturaBotonContinuar.unload();
        regionBotonContinuar = null;
        texturaBotonMenu.unload();
        regionBotonMenu = null;
    }

    public void cargarRecursosGanaste() {
        try {
            // Carga la imagen de fondo de la pantalla Splash
            texturaFondoGanaste = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "ganaste.png");
            regionFondoGanaste = TextureRegionFactory.extractFromTexture(texturaFondoGanaste);
            texturaFondoGanaste.load();
            // Carga la imagen del botón regresar
            texturaBtnRegresar = new BitmapTextureAtlas(actividadJuego.getTextureManager(),
                    128,128, TextureOptions.BILINEAR);
            regionBtnRegresar = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnRegresar,
                    actividadJuego,"back.png",0,0);
            texturaBtnRegresar.load();
        } catch (IOException e) {
            Log.d("cargarRecursosAcercaDe","No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosGanaste() {
        // Fondo
        texturaFondoGanaste.unload();
        regionFondoGanaste = null;
        // Btn regresar
        texturaBtnRegresar.unload();
        regionBtnRegresar = null;
    }

    public void cargarRecursosJuego2(){
        //PARA NO LLAMAR AL METODO MUCHAS VECES
        TextureManager admTexturas = actividadJuego.getTextureManager();
        AssetManager assets = actividadJuego.getAssets();
        try{
            //Fondo Escena
            texturaFondoJuegoDos = new AssetBitmapTexture(admTexturas,assets, "fondoJuegoDos.png");
            regionFondoJuegoDos = TextureRegionFactory.extractFromTexture(texturaFondoJuegoDos);
            texturaFondoJuegoDos.load();
            //Sprite del Shooter
            texturaShooter = new AssetBitmapTexture(admTexturas,assets, "shooter.png");
            regionShooter = TextureRegionFactory.extractFromTexture(texturaShooter);
            texturaShooter.load();
            //Sprite del shooter con disparo
            texturaShooterDisparo = new AssetBitmapTexture(admTexturas,assets, "shooterConDisparo.png");
            regionShooterDisparo = TextureRegionFactory.extractFromTexture(texturaShooterDisparo);
            texturaShooterDisparo.load();
            //Bala
            texturaBala = new AssetBitmapTexture(admTexturas,assets,"bala.png");
            regionBala = TextureRegionFactory.extractFromTexture(texturaBala);
            texturaBala.load();
            //Cabezas
            texturaCabezaHombre = new AssetBitmapTexture(admTexturas,assets,"cabezaHombre.png");
            regionCabezaHombre = TextureRegionFactory.extractFromTexture(texturaCabezaHombre);
            texturaCabezaHombre.load();
            //Fondo pausa
            texturaFondoPausaDos = new AssetBitmapTexture(admTexturas,
                    assets, "fondoPausa.png");
            regionFondoPausaDos = TextureRegionFactory.extractFromTexture(texturaFondoPausaDos);
            texturaFondoPausaDos.load();
            //CARGAR MENSAJE GANASTE
            texturaGanaste = new AssetBitmapTexture(admTexturas,
                    assets, "pantallaganador.png");
            regionGanaste = TextureRegionFactory.extractFromTexture(texturaGanaste);
            texturaGanaste.load();
            //Cargar mensaje perdiste
            texturaPerdiste = new AssetBitmapTexture(admTexturas,
                    assets, "pantalladerrota.png");
            regionPerdiste = TextureRegionFactory.extractFromTexture(texturaPerdiste);
            texturaPerdiste.load();
            // Carga la imagen del botón pausa
            texturaBtnPausaDos = new BitmapTextureAtlas(actividadJuego.getTextureManager(), 128,128, TextureOptions.BILINEAR);
            regionBtnPausaDos = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnPausaDos, actividadJuego,"bPausa.png",0,0);
            texturaBtnPausaDos.load();
        }catch(IOException e){
            Log.d("cargarRecursosJuego2", "No se pueden cargar las imagenes");
        }
        //Cargar TIMER
        texturaTimerDos = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),648,216);
        regionTimerDos = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaTimerDos,actividadJuego, "timer.png",6,2);
        try {
            texturaTimerDos.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
        }
        texturaTimerDos.load();
        //CARGAR SHOOTER MURIENDO
        texturaShooterMuriendo = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),3401,2267);
        regionShooterMuriendo = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaShooterMuriendo,actividadJuego, "shootermuriendo.png",3,6);
        try {
            texturaShooterMuriendo.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del munecoQuemandose");
        }
        texturaShooterMuriendo.load();
        cargarBotonesPausaDos();
    }

    private void cargarBotonesPausaDos() {
        try {
            // Carga la imagen del botón continuar
            texturaBotonContinuarDos = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnContinue.png");
            regionBotonContinuarDos = TextureRegionFactory.extractFromTexture(texturaBotonContinuarDos);
            texturaBotonContinuarDos.load();

            // Carga la imagen para el botón menu
            texturaBotonMenuDos = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnMenu.png");
            regionBotonMenuDos = TextureRegionFactory.extractFromTexture(texturaBotonMenuDos);
            texturaBotonMenuDos.load();

        } catch (IOException e) {
            Log.d("cargarBotonesMenu", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosJuego2(){
        texturaFondoJuegoDos.unload();
        regionFondoJuegoDos = null;

        texturaShooter.unload();
        regionShooter = null;

        texturaShooterDisparo.unload();
        regionShooterDisparo = null;
        //Pausa
        texturaFondoPausaDos.unload();
        regionFondoPausaDos = null;
        texturaBtnPausaDos.unload();
        regionBtnPausaDos = null;
        texturaBotonContinuarDos.unload();
        regionBotonContinuarDos = null;
        texturaBotonMenuDos.unload();
        regionBotonMenuDos = null;

        texturaBala.unload();
        regionBala = null;

        texturaPerdiste.unload();
        regionPerdiste =null;

        texturaCabezaHombre.unload();
        regionCabezaHombre = null;

        texturaGanaste.unload();
        regionGanaste = null;

        texturaTimerDos.unload();
        texturaTimerDos = null;

        texturaShooterMuriendo.unload();
        regionShooterMuriendo =null;
    }

    public void cargarRecursosJuego3(){
        //PARA NO LLAMAR AL METODO MUCHAS VECES
        TextureManager admTexturas = actividadJuego.getTextureManager();
        AssetManager assets = actividadJuego.getAssets();
        try {
            // Carga la imagen de fondo de la pantalla Estado Juego
            texturaFondoJuegoTres = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "fondoniveltres.png");
            regionFondoJuegoTres = TextureRegionFactory.extractFromTexture(texturaFondoJuegoTres);
            texturaFondoJuegoTres.load();
            //Fondo pausa
            texturaFondoPausaTres = new AssetBitmapTexture(admTexturas,
                    assets, "fondoPausa.png");
            regionFondoPausaTres = TextureRegionFactory.extractFromTexture(texturaFondoPausaTres);
            texturaFondoPausaTres.load();
            // Carga la imagen del botón pausa
            texturaBtnPausaTres = new BitmapTextureAtlas(actividadJuego.getTextureManager(), 128,128, TextureOptions.BILINEAR);
            regionBtnPausaTres = BitmapTextureAtlasTextureRegionFactory.createFromAsset(texturaBtnPausaTres, actividadJuego,"bPausa.png",0,0);
            texturaBtnPausaTres.load();
            //Asteroide
            texturaAsteroide = new AssetBitmapTexture(admTexturas,assets, "asteroide2.png");
            regionAsteroide = TextureRegionFactory.extractFromTexture(texturaAsteroide);
            texturaAsteroide.load();


        } catch (IOException e) {
            Log.d("cargarRecursosJuego3","No se puede cargar el fondo");
        }

        //Nave Espacial
        texturaNave = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),128,227);
        regionNave = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaNave,actividadJuego, "nave.png",1,4);
        try {
            texturaNave.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0, 0, 0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite de la nave espacial");
        }
        texturaNave.load();

        //Nave Chocando
        texturaNaveChocando = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),1672,1188);
        regionNaveChocando = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaNaveChocando,actividadJuego, "navechocando.png",4,5);
        try {
            texturaNaveChocando.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
        }
        texturaNaveChocando.load();

        //Cargar TIMER
        texturaTimerTres = new BuildableBitmapTextureAtlas(actividadJuego.getTextureManager(),648,216);
        regionTimerTres = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(
                texturaTimerTres,actividadJuego, "timer.png",6,2);
        try {
            texturaTimerTres.build(new BlackPawnTextureAtlasBuilder<IBitmapTextureAtlasSource, BitmapTextureAtlas>(0,0,0));
        } catch (ITextureAtlasBuilder.TextureAtlasBuilderException e) {
            Log.d("onCreateResources","No se puede cargar la imagen para el Sprite del perro Animado");
        }
        texturaTimerTres.load();
        cargarBotonesPausaTres();
    }

    private void cargarBotonesPausaTres() {
        try {
            // Carga la imagen del botón continuar
            texturaBotonContinuarTres = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnContinue.png");
            regionBotonContinuarTres = TextureRegionFactory.extractFromTexture(texturaBotonContinuarTres);
            texturaBotonContinuarTres.load();

            // Carga la imagen para el botón menu
            texturaBotonMenuTres = new AssetBitmapTexture(actividadJuego.getTextureManager(),
                    actividadJuego.getAssets(), "btnMenu.png");
            regionBotonMenuTres = TextureRegionFactory.extractFromTexture(texturaBotonMenuTres);
            texturaBotonMenuTres.load();

        } catch (IOException e) {
            Log.d("cargarBotonesMenu", "No se pueden cargar las imágenes");
        }
    }

    public void liberarRecursosJuego3(){
        texturaFondoJuegoTres.unload();
        regionFondoJuegoTres = null;
        //Pausa
        texturaFondoPausaTres.unload();
        regionFondoPausaTres = null;
        texturaBtnPausaTres.unload();
        regionBtnPausaTres = null;
        texturaBotonContinuarTres.unload();
        regionBotonContinuarTres = null;
        texturaBotonMenuTres.unload();
        regionBotonMenuTres = null;

        texturaNave.unload();
        regionNave = null;

        texturaAsteroide.unload();
        regionAsteroide = null;

        texturaNaveChocando.unload();
        regionNaveChocando = null;

        texturaTimerTres.unload();
        regionTimerTres = null;
    }

}